const api = require("../../request/api")
const request = require("../../request/request")
const util = require("../../utils/util")
const App = getApp();

// 优惠券过期时间定时器
let timer = null
// pages/order/pay.js
Page({

    /**
     * 页面的初始数据
     */
    data: {
        address_detail: {},

        // 优惠券类目
        couTypeName: ['', '产品券', '', '', '', '', '', '满减券', '无门槛', '新人券'],

        // 可用金额最大的优惠券金额和索引
        // 过期时间 单位：天
        bestCouValue: 0,
        bestCouIndex: -1,
        bestUseTime: ' ',

        // 可领取金额最大的优惠券金额和索引
        AbestCouValue: 0,
        AbestCouIndex: -1,
        btnText: '领取使用',

        // 所有已经领取的优惠券
        allCoupon: [],

        // 优惠券的使用状态 0无券可用 1有券未用 2有券已用
        // 所选用优惠券索引
        // 可用券列表
        // 可领取优惠券列表
        // 优惠券弹框标识
        couUseStatus: 0,
        couIndex: -1,
        couponValue: 0,
        couponList: [
        ],
        AvailableCou: [
        ],
        isShowCoupon: false,

        // 购买商品的列表，单个商品跳转往里追加，购物车跳转直接查购物车数据负值
        cart_list: [],
        list: [],

        //  0是购物车跳转过来全部购买、 1是单个商品跳转、2是购买多个指定商品
        type: '-1',
        uid: '',
        isNewUser: App.globalData.fulluserInfo?.is_new_user == 1 ? true : false,


        // 灰色遮罩层标识
        // 优惠券留客提示框的标识
        if_show_mask: false,
        if_show_mask2: false,
        if_show_end_paying_box: false,

        // 判断是否已经选择了收货地址
        // 邮寄地址列表弹出框标识
        // 邮寄地址列表
        // 所选地址的id
        if_address: false,
        if_show_box: false,
        address_list: [],
        chosen_id: 0,

        // 自提地址列表弹出框标识
        // 自提地址列表
        if_show_box_delivery: false,
        delivery_list: [],
        chosen_id_delivery: 0,

        // ？？？
        if_has_default: false,

        // 单个商品的 id、购买数量、规格
        good_id: '',
        number: 1,
        productID: -1,

        // 原总价
        // 优惠后的实际付款
        total_price: 0,
        submit_price: 0,

        // 不折扣的总价
        total_price2: 0,

        // 添加订单后本订单的编号
        orderIdCode: '',

        pay_waiting: false,
        options: {},

        visible: false,

        isVip: false,
        VipGrade: 0,

        // 缓存备注
        noteValue: '',
        // 统计字数
        strlength: 0,
        // 底部高度
        howtall: 20,

        positionStauts: 'relative',
        keyboardheight: 0,
        zindex: 5
    },
    onUnload() {
        // 清除优惠券过期时间定时器
        if (timer) {
            clearInterval(timer)
            timer = null
        }
    },
    onHide() {

    },
    /**
     * 生命周期函数--监听页面加载
     */
    onLoad: async function (options) {
        // console.log('options', options);
        await this.init_data(options)
        // await this.get_address_list()
        // await this.get_address()

        await this.getAllmyCoupon()
        await this.getAbledCoupon()

        //this.get_delivery_list()
    },

    // 初始化数据，判断是哪一类的订单结算，获取对应商品数据展示
    async init_data(options) {
        console.log('options', options)

        // 计算折扣
        let discount = 1
        let VipGrade = App.globalData.VipGrade
        switch (VipGrade) {
            case 1:
                discount = 0.98
                break;
            case 2:
                discount = 0.95
                break;
            case 3:
                discount = 0.92
                break;
            default:
                break;
        }

        this.setData({
            uid: App.globalData.uid,
            // uid: 3357,

            isVip: App.globalData.isVip,
            VipGrade: App.globalData.VipGrade,
            discount,
            options,
            type: options.type,
        })

        // type=1，用户直接从商品详情里购买单个商品
        if (options.type == 1) {
            this.setData({
                good_id: options.good_id,
                product_id: options.productID
            })
            let params = {
                id: options.good_id
            }
            let res = await request.post(api.goods_details, params)

            // 判断规格 获取对应规格价格
            if (options.productID != -1) {
                res.products_array.forEach(pitem => {
                    if (pitem.id == options.productID) {
                        // 规格价对应会员折扣价
                        res.discountPrice = (pitem.sell_price * this.data.discount).toFixed(2)
                        // 删除线展示价格
                        res.sell_price = pitem.sell_price
                        res.pname = pitem.name
                    }
                });
            } else {
                res.discountPrice = (res.sell_price * this.data.discount).toFixed(2)
            }
            let cart_list = []
            cart_list.push(res)
            cart_list[0].goods_num = options.number

            // 按店铺分开
            let newlist = await this.handleCartList(cart_list)

            this.setData({
                cart_list: newlist,
                goods_detail: res,
                number: options.number
            })

            this.counting_price()

        }
        // type=2，用户从购物车多选商品结算
        else if (options.type == 2) {
            let { goodstr } = options
            let goodarr = JSON.parse(goodstr)
            let cart_list = []
            let number = 0
            for (let i = 0; i < goodarr.length; i++) {

                let res = await request.post(api.goods_details, { id: goodarr[i].id })
                res.discountPrice = (res.sell_price * this.data.discount).toFixed(2)
                res.buy_num = goodarr[i].num
                res.product_id = goodarr[i].product_id
                // 有规格id 选择规格的价格展示
                if (goodarr[i].product_id) {
                    res.products_array.forEach(pitem => {
                        if (pitem.id == goodarr[i].product_id) {
                            res.discountPrice = (pitem.sell_price * this.data.discount).toFixed(2)
                            res.sell_price = pitem.sell_price
                            res.pname = pitem.name
                        }
                    });
                }

                cart_list.push(res)
                number += goodarr[i].num
            }
            // 按店铺分开
            let newlist = await this.handleCartList(cart_list)

            this.setData({
                cart_list: newlist,
                number
            })
            this.counting_price()
            // console.log(this.data.cart_list, this.data.number);
        }
        else {
            // type=0，用户清空购物车商品
            let params = {
                uid: this.data.uid
            }
            let res = await request.post(api.cart_list, params)
            let list = res.goods_list

            // 循环中有异步操作，所以使用原生for循环
            for (let i = 0; i < list.length; i++) {
                list[i].discountPrice = (list[i].sell_price * this.data.discount).toFixed(2)
                let gooddetail = await request.post(api.goods_details, { id: list[i].goods_id })
                let shopdetail = await request.post(api.shopDetail, { id: list[i].seller_id })
                list[i].parent_id = shopdetail?.parent_id
                let products = gooddetail.products_array

                // 下面循环主要是为了添加每个规格的名字
                products.forEach(pitem => {
                    if (pitem.id == list[i].product_id) {
                        list[i].pname = pitem.name
                        return
                    }
                });
            }

            let newlist = await this.handleCartList(list)
            // console.log(newlist);
            this.setData({
                cart_list: newlist,
                number: res.total_goods_nums
            })
            this.counting_price()
        }
        // this.getAbledCoupon()
    },

    // 记录备注
    inputHandler(e) {
        let str = e.detail.value
        let strlength = str.length
        // console.log(str, strlength);
        this.setData({
            noteValue: str,
            strlength
        })
    },

    // 按照店铺排序商品
    async handleCartList(list) {
        let sellerObj = {}
        // 遍历利用店铺id，设置该店铺的商品数组，最后按顺序堆放成一个数组
        for (let i = 0; i < list.length; i++) {
            let sellerID = list[i].seller_id
            if (sellerObj[sellerID]) {
                sellerObj[sellerID].push(list[i])
            } else {
                sellerObj[sellerID] = []
                let shopDetail = await request.postall(api.shopDetail, { id: sellerID })
                if (shopDetail.code == 0) {
                    list[i].showShop = true
                    list[i].shopDetail = {}
                    list[i].shopDetail['name'] = shopDetail.data.true_name
                    list[i].shopDetail['logo'] = shopDetail.data.logo
                }
                sellerObj[sellerID].push(list[i])
            }
        }
        let newlist = []
        for (let i in sellerObj) {
            newlist.push(...sellerObj[i])
        }
        // console.log('newlist', newlist);
        return newlist
    },

    taller() {
        if (this.data.pay_waiting) {
            wx.showModal({
                title: '温馨提示',
                content: '您已提交订单，备注需要联系客服添加哦',
                showCancel: false,
                success(res) {
                    if (res.confirm) {
                        console.log('用户点击确定')
                    } else if (res.cancel) {
                        console.log('用户点击取消')
                    }
                }
            })
            return
        }

        // this.setData({
        //     howtall: 40
        // })
        // wx.pageScrollTo({
        //     scrollTop: 1000
        // })
        // console.log('taller', this.data.howtall);
    },
    // resettall() {
    //     this.setData({
    //         howtall: 20
    //     })
    // },

    // 自定义弹出层取消按钮回调
    cancelMethod() {
        this.setData({
            visible: false
        })
    },

    // 自定义弹出层点击空白处显示隐藏回调
    onVisibleChange(e) {
        this.setData({
            visible: e.detail.visible,
        });
    },

    // 手机授权按钮的回调
    async getrealtimePhoneNumber(e) {
        // console.log(e.detail.code)  // 拒绝：undefined 同意：code（和login的code不一样）
        // console.log(e.detail.errMsg) // 回调信息（成功失败都会返回）拒绝：fail user deny 同意：ok
        // console.log(e.detail.errno)  // 错误码（失败时返回）一般情况：undefined  使用次数上限：e.detail.errno===1400001

        // 先隐藏弹出层
        this.setData({
            visible: false
        })

        // console.log('e', e);
        // 用户同意且未达使用次数上限
        if (e.detail.errno == undefined && e.detail.code) {
            console.log('e.detail.code', e.detail.code);
            // 成功手机号授权会返回 true
            let phoneflag = await App.setPhone(e.detail.code)
            console.log('phoneflag', phoneflag);
            // 成功后请求用户完整信息
            if (phoneflag) {
                // 成功获取最新完整用户信息
                let fullRes = await App.getMyFullInfo()
                console.log('fullRes', fullRes);
                if (fullRes) {
                    this.init_data(this.data.options)
                    this.paying()
                    // console.log('是否有手机号？', this.data.mobile);
                } else {
                    util.showFail('信息获取超时请稍后重试')
                }
            }
        } else {
            util.showToast('已取消授权')
        }
    },


    // 优惠券列表弹出框拉起
    showCouponBox() {
        if (this.data.pay_waiting) {
            wx.showModal({
                title: '温馨提示',
                content: '选择优惠券需要重新下单哦',
                showCancel: false,
                success(res) {
                    if (res.confirm) {
                        console.log('用户点击确定')
                    } else if (res.cancel) {
                        console.log('用户点击取消')
                    }
                }
            })
            return
        }
        this.setData({
            if_show_mask: true,
            isShowCoupon: true
        })
    },
    // 收起
    closeCouponBox() {
        this.setData({
            if_show_mask: false,
            isShowCoupon: false
        })
    },

    // 优惠券勾选框
    onCouChange(event) {
        const { value } = event.detail;
        // 取消使用
        if (this.data.couIndex == value) {
            this.setData({
                couIndex: -1,
                couUseStatus: 1,
                couponValue: 0
            });
            this.closeCouponBox()
            this.counting_price()
            return
        }
        // console.log('dddfgdsg', this.data.couponList[value]);
        this.setData({
            couIndex: value,
            couUseStatus: 2,
            couponValue: this.data.couponList[value].value
        });
        this.closeCouponBox()
        this.counting_price()

    },

    // 减少商品数量
    async minus(e) {
        if (this.data.type == 1) {
            if (this.data.number > 1) {
                this.setData({ number: --this.data.number })
            }
        } else {

            if (this.data.number > 1) {
                let index = e.currentTarget.dataset.index
                let cart_list = this.data.cart_list
                let str = `cart_list[${index}].buy_num`

                // cart_list[index].buy_num = --cart_list[index].buy_num
                // this.setData({ cart_list: cart_list })
                this.setData({ [str]: --cart_list[index].buy_num })
                // console.log('cart_list[index]', cart_list[index]);
                let params = {
                    uid: this.data.uid,
                    goods_id: this.data.type == 2 ? cart_list[index]['id'] : cart_list[index]['goods_id'],
                    goods_sku_id: cart_list[index]['product_id']
                }
                let res = await request.post(api.cart_minus, params)

                if (res) {
                    let cartRes = await request.post(api.cart_list, { uid: this.data.uid })
                    // console.log(cartRes);
                    App.globalData.cartnum = cartRes.total_goods_nums
                }

            }
        }
        // 计算金额 筛选可用优惠券
        this.counting_price()
        this.getAbledCoupon()

    },

    // 增加商品数量
    async plus(e) {
        if (this.data.type == 1) {
            this.setData({ number: ++this.data.number })
        } else {
            //来源：清空购物车 指定多个商品购买
            let index = e.currentTarget.dataset.index
            let cart_list = this.data.cart_list
            let str = `cart_list[${index}].buy_num`
            // cart_list[index].buy_num = ++cart_list[index].buy_num
            this.setData({ [str]: ++cart_list[index].buy_num })
            // console.log('cart_list[index]', cart_list[index]);

            let params = {
                uid: this.data.uid,
                goods_id: this.data.type == 2 ? cart_list[index]['id'] : cart_list[index]['goods_id'],
                goods_sku_id: cart_list[index]['product_id']

            }
            let res = await request.post(api.cart_add, params)
            if (res) {
                let cartRes = await request.post(api.cart_list, { uid: this.data.uid })
                // console.log(cartRes);
                App.globalData.cartnum = cartRes.total_goods_nums
            }

        }
        // 计算金额 筛选可用优惠券
        this.counting_price()
        this.getAbledCoupon()
    },

    // 直接输入商品数量
    async inputNum(e) {
        let value = e.detail.detail.value
        if (this.data.type == 1) {
            this.setData({ number: value })
        } else {
            //来源：清空购物车 指定多个商品购买
            let cart_list = this.data.cart_list
            let index = e.currentTarget.dataset.index
            let originnum = cart_list[index].buy_num
            let str = `cart_list[${index}].buy_num`
            this.setData({ [str]: value })
            let sendPath = ''
            if (value - originnum > 0) {
                sendPath = api.cart_add
            } else if (value - originnum < 0) {
                sendPath = api.cart_minus
            } else {
                // 未改变购物数量，直接退出
                return
            }
            let num = Math.abs(value - originnum);
            let params = {
                uid: this.data.uid,
                goods_id: this.data.type == 2 ? cart_list[index]['id'] : cart_list[index]['goods_id'],
                goods_sku_id: cart_list[index]['product_id'],
                goods_num: num
            }
            let res = await request.post(sendPath, params)
            if (res) {
                let cartRes = await request.post(api.cart_list, { uid: this.data.uid })
                // console.log(cartRes);
                App.globalData.cartnum = cartRes.total_goods_nums
            }

        }
        // 计算金额 筛选可用优惠券
        this.counting_price()
        this.getAbledCoupon()
    },

    // 请求自提地址列表
    get_delivery_list() {
        let params = {
        }
        request.post(api.deliverylist, params).then(res => {
            this.setData({
                delivery_list: res
            })
        })
    },

    // 设置顶部页面的地址信息，利用默认地址或者地址列表中第一个地址
    get_address() {
        let params = {
            uid: this.data.uid
        }
        request.post(api.addresslist, params).then(res => {
            // console.log('地址列表res:', res);
            // 没地址则直接退出
            if (res.length == 0) return
            this.setData({
                address_list: res
            })

            // 查找是否有默认地址
            for (let i of res) {
                if (i.is_default) {
                    this.setData({
                        address_detail: i,
                        if_address: true,
                        aid: i.id,
                        chosen_id: i.id,
                    })
                    return
                }
            }
            // 如果地址列表里有地址但没有默认的
            if (this.data.if_address == false) {
                this.setData({
                    address_detail: res[0],
                    if_address: true,
                    aid: res[0].id,
                    chosen_id: res[0].id
                })
            }
        })

    },

    // 去往领券中心
    go_to_couponCenter() {
        let url = '/coupon/couCenter'
        wx.navigateTo({
            url,
        })
    },
    // 添加地址
    go_add_address() {
        let url = '/pages/address/add?type=' + this.data.type + '&good_id=' + this.data.good_id
        wx.navigateTo({
            url,
        })
    },

    // 编辑地址
    go_edit(e) {
        let url = '/pages/address/edit?id=' + e.currentTarget.dataset.id + '&uid=' + this.data.uid
        wx.navigateTo({
            url,
        })
    },

    // 用户更换邮寄地址
    change_address(e) {
        let chosen_id = e.currentTarget.dataset.id
        this.setData({
            chosen_id,
            chosen_id_delivery: 0,
            if_address: true
        })
        this.get_address_detail(chosen_id)
    },

    // 用户更换自提地址
    change_delivery(e) {
        let chosen_id_delivery = e.currentTarget.dataset.id
        this.setData({
            chosen_id_delivery,
            chosen_id: 0,
            if_address: true
        })
        this.get_delivery_detail(chosen_id_delivery)
    },

    // 计算价格
    counting_price() {
        let discount = this.data.discount
        let type = this.data.type
        let number = 0

        // 折扣和不折扣的总价，用不折扣的总价判别满减条件是否符合
        let total_price = 0
        let total_price2 = 0

        // 清空购物车
        if (type == 0) {
            this.data.cart_list.forEach(item => {
                let goods_num = item.buy_num
                let single_price = util.accMul(item.sell_price * discount, goods_num)
                let single_price2 = util.accMul(item.sell_price, goods_num)

                total_price += single_price
                total_price2 += single_price2

                number += goods_num
            });
            // for (let i = 0; i < this.data.cart_list.length; i++) {
            //     let goods_num = this.data.cart_list[i].buy_num
            //     let single_price = util.accMul(this.data.cart_list[i].sell_price * discount, goods_num)
            //     let single_price2 = util.accMul(this.data.cart_list[i].sell_price, goods_num)

            //     total_price += single_price
            //     total_price2 += single_price2

            //     number += goods_num
            // }
        }
        // 多选购买
        else if (type == 2) {
            this.data.cart_list.forEach(item => {
                let goods_num = item.buy_num
                let single_price = 0, single_price2 = 0
                // 规格商品
                if (item.product_id) {
                    item.products_array.forEach(pitem => {
                        if (pitem.id == item.product_id) {
                            single_price = util.accMul(pitem.sell_price * discount, goods_num)
                            single_price2 = util.accMul(pitem.sell_price, goods_num)
                            return
                        }
                    });
                }
                // 无规格商品
                else {
                    single_price = util.accMul(item.sell_price * discount, goods_num)
                    single_price2 = util.accMul(item.sell_price, goods_num)
                }

                total_price += single_price
                total_price2 += single_price2

                number += goods_num
            });
        }
        else if (type == 1) {

            let goods_num = parseInt(this.data.number)
            let single_price = 0, single_price2 = 0;
            // 不从购物车取值，直接购买渠道
            // 直接购买商品带规格
            console.log(this.data.product_id);
            if (this.data.product_id != -1) {
                let products = this.data.cart_list[0].products_array
                products.forEach(item => {
                    if (item.id == this.data.product_id) {
                        single_price = util.accMul(item.sell_price * discount, goods_num)
                        single_price2 = util.accMul(item.sell_price, goods_num)
                        console.log(single_price, single_price2);

                        return
                    }
                });
            }
            // 不带规格直接购买
            else {
                single_price = util.accMul(this.data.cart_list[0].sell_price * discount, goods_num)
                single_price2 = util.accMul(this.data.cart_list[0].sell_price, goods_num)
            }

            console.log(single_price, single_price2);
            total_price += single_price
            total_price2 += single_price2

            number += goods_num
        }

        // 保留两位小数
        total_price = parseFloat(total_price.toFixed(2))
        total_price2 = parseFloat(total_price2.toFixed(2))

        let submit_price = total_price
        if (this.data.couUseStatus == 2) {
            submit_price -= this.data.couponValue
            submit_price = parseFloat(submit_price.toFixed(2))
        }

        // 非会员且未满额就需要加邮费(未使用优惠券前的额度小于38)
        if (!this.data.isVip && total_price < 38) {
            submit_price += 6
        }

        this.setData({
            total_price,
            total_price2,
            number,
            submit_price,
        })
    },

    // 根据所选自提点，更改页面顶部地址
    get_delivery_detail(id) {
        util.showLoading('正在更改地址')
        let params = {
            id
        }
        request.post(api.deliverydetail, params).then(res => {
            this.setData({
                address_detail: res
            })
            util.hideLoading(0)
        })
    },

    // 根据所选地址id，请求对应地址信息更改页面顶部地址
    get_address_detail(id) {
        util.showLoading('正在更改地址')
        let params = {
            id
        }
        request.post(api.addressdetail, params).then(res => {
            this.setData({
                address_detail: res,
                // 关闭弹出框
                if_show_box: false,
                if_show_mask: false
            })

            util.hideLoading()
        })
    },

    // 获取邮寄地址列表
    get_address_list() {
        let params = {
            uid: this.data.uid
        }
        request.post(api.addresslist, params).then(res => {
            this.setData({
                address_list: res
            })
        })
    },

    // 选择地址拉起地址列表框
    choose_address() {
        if (this.data.pay_waiting) {
            wx.showModal({
                title: '温馨提示',
                content: '需要修改收货地址请重新下单',
                showCancel: false,
                success(res) {
                    if (res.confirm) {
                        console.log('用户点击确定')
                    } else if (res.cancel) {
                        console.log('用户点击取消')
                    }
                }
            })
            return
        }
        this.setData({
            if_show_box: true,
            if_show_mask: true
        })
    },

    // 选择自提地址 拉起地址框
    choose_delivery() {
        if (this.data.pay_waiting) {
            wx.showModal({
                title: '温馨提示',
                content: '需要修改收货地址请重新下单',
                showCancel: false,
                success(res) {
                    if (res.confirm) {
                        console.log('用户点击确定')
                    } else if (res.cancel) {
                        console.log('用户点击取消')
                    }
                }
            })
            return
        }
        this.setData({
            if_show_box_delivery: true
        })
    },

    // 关闭邮寄地址框、遮罩层(点击空白区关闭所有弹出)
    clear_mask() {
        clearInterval(timer)
        this.setData({
            if_show_box: false,
            if_show_mask: false,
            isShowCoupon: false,
            if_show_end_paying_box: false
        })
    },

    // 关闭自提地址框、遮罩层
    clear_mask_delivery() {
        this.setData({
            if_show_mask: false,
            if_show_box_delivery: false
        })
    },

    // 提交订单时判断优惠券使用情况
    setCouponId_orNot(post_data) {
        // 无优惠券
        if (this.data.couUseStatus != 2) return post_data
        // 有使用优惠券
        let pid = this.data.couponList[this.data.couIndex].pid
        post_data.ticket_ids = `${pid}`
        return post_data
    },

    // 提交订单时修改订单类型
    get_post_data_type(post_data, type) {
        // type=2，用户直接从商品详情里购买单个商品
        if (type == 2) {
            post_data.id = this.data.good_id
        }
        if (type == 1) {
            post_data.id = this.data.good_id
        }
        // console.log(type)
        // type=7，用户从购物车购买商品,后台会直接读取cartlist里的商品内容，在支付后会清空cartlist。
        if (type == 0) {
            post_data.type = 0
        }
        return post_data
    },

    // 提交订单时添加地址参数,选择邮寄或是自提，选择哪一类和哪一个
    get_post_data_address(post_data) {
        let chosen_id = this.data.chosen_id
        let chosen_id_delivery = this.data.chosen_id_delivery

        // 初始两个类型的地址id都是0 如果某一个非0则是选择了对应地址
        if (chosen_id != 0 && chosen_id_delivery == 0) {
            post_data.aid = chosen_id
        }
        if (chosen_id == 0 && chosen_id_delivery != 0) {
            post_data.takeself = chosen_id_delivery
        }
        return post_data
    },

    // 单独处理套餐商品
    handlePackageOrder(post_data) {
        if (post_data.goods.length == 1 && this.data.cart_list[0].type == "package") {
            post_data.goods_id = post_data.goods[0].goods_id
            post_data.goods_num = post_data.goods[0].goods_num
            post_data.goods_sku_id = post_data.goods[0].goods_sku_id
            return post_data
        } else return post_data
    },

    // 1.开始支付，支付流程是先调用orderadd生成一个订单，输出一个订单号
    // 2.输入一个订单号，调用orderpay3，输出微信支付所需要的签名信息
    // 3.输入签名信息，调用微信的支付接口，完成支付后跳转页面，在此期间可修改订单的状态status
    paying() {
        // 如果没有授权手机号，拉起授权
        console.log(App.globalData.mobile);
        // !App.globalData.mobile
        if (!App.globalData.mobile) {
            this.setData({
                visible: true
            })
            return
        }

        // 检查用户是否选取了地址
        if (!this.data.if_address) {
            util.showToast('请选择一个地址')
            return
        }

        let type = this.data.type
        if (type == 1) {
            // 基本的请求参数信息
            let post_data = {
                uid: this.data.uid,
                type,
                goods: [{
                    goods_id: this.data.good_id, // ????
                    goods_num: this.data.number,
                    goods_sku_id: this.data.product_id == -1 ? "" : this.data.product_id,
                    seller_id: this.data.goods_detail.seller_id,
                    parent_seller_id: this.data.goods_detail.parent_id
                }],
                note: this.data.noteValue
            }
            // 根据不同的type来修改对应的请求参数
            // post_data = this.get_post_data_type(post_data, type)

            // 根据用户是用自选的地址，还是自提点的地址，来调整请求参数
            post_data = this.get_post_data_address(post_data)
            post_data = this.setCouponId_orNot(post_data)
            post_data = this.handlePackageOrder(post_data)
            // console.log(post_data);
            // return false

            // 开始支付流程 获取生成订单号 根据订单号获得微信支付参数
            request.post(api.orderaddv3, post_data).then(res => {
                // res是生成的订单号，先保存该订单编号以便用户继续支付
                this.setData({
                    orderIdCode: res[0]
                })
                request.post(api.orderpay3, { id: res[0] }).then(res => {
                    this.wx_pay(res)
                })
            })
        }
        else if (type == 2) {
            // console.log('购物车选付，未全选')
            let cart_list = this.data.cart_list
            let goods = []
            cart_list.forEach(item => {
                goods.push({
                    goods_id: item.id,
                    goods_num: item.buy_num,
                    goods_sku_id: item.product_id == -1 ? "" : item.product_id,
                    seller_id: item.seller_id,
                    parent_seller_id: item.parent_id
                })
            })
            let post_data = {
                uid: this.data.uid,
                type: 2,
                goods,
                note: this.data.noteValue
            }
            // 根据不同的type来修改对应的请求参数
            // post_data = this.get_post_data_type(post_data, type)

            // 根据用户是用自选的地址，还是自提点的地址，来调整请求参数
            post_data = this.get_post_data_address(post_data)
            post_data = this.setCouponId_orNot(post_data)
            post_data = this.handlePackageOrder(post_data)


            // 开始支付流程 获取生成订单号 根据订单号获得微信支付参数
            request.post(api.orderaddv3, post_data).then(res => {
                // 添加订单获取订单号
                console.log('购物车商品订单号2：', res);

                // console.log(res);
                // return
                this.setData({
                    orderIdCode: res[0]
                })

                request.post(api.orderpay3, { id: res[0] }).then(res => {
                    // res包含拉起微信支付的参数
                    this.wx_pay(res)
                })
            })
        }
        else {
            // console.log('清空购物车 type=0')
            let cart_list = this.data.cart_list
            let goods = []
            cart_list.forEach(item => {
                goods.push({
                    goods_id: item.goods_id,
                    goods_num: item.buy_num,
                    goods_sku_id: item.product_id == 0 ? "" : item.product_id,
                    seller_id: item.seller_id,
                    parent_seller_id: item.parent_id
                })
            })
            let post_data = {
                uid: this.data.uid,
                type: 2,
                goods,
                note: this.data.noteValue
            }
            // 根据不同的type来修改对应的请求参数
            // post_data = this.get_post_data_type(post_data, type)

            // 根据用户是用自选的地址，还是自提点的地址，来调整请求参数
            post_data = this.get_post_data_address(post_data)
            post_data = this.setCouponId_orNot(post_data)
            post_data = this.handlePackageOrder(post_data)
            // console.log(post_data);
            // return

            // 开始支付流程 获取生成订单号 根据订单号获得微信支付参数
            request.post(api.orderaddv3, post_data).then(res => {
                // 添加订单获取订单号
                console.log('购物车商品订单号4：', res);

                this.setData({
                    orderIdCode: res[0]
                })

                request.post(api.orderpay3, { id: res[0] }).then(res => {
                    // res包含拉起微信支付的参数
                    this.wx_pay(res)
                })
            })

        }
    },

    // 拉起微信支付
    wx_pay(res) {
        const that = this
        let post_data = res
        console.log(post_data);
        this.pay_post_data = post_data
        wx.navigateToMiniProgram({
            appId: 'wxef277996acc166c3', // 目标小程序的appid
            extraData: post_data,        // 需要传递给目标小程序的数据，可选
            success(res) {
                // 打开成功的回调
            },
            fail(err) {
                // 打开失败的回调
                that.setData({ pay_waiting: true });
            }
        });

        // wx.requestPayment({
        //     nonceStr: post_data.nonceStr,
        //     package: post_data.package,
        //     paySign: post_data.paySign,
        //     timeStamp: post_data.timeStamp,
        //     signType: post_data.signType,
        //     success(res) {
        //         util.showSuccess('支付成功');
        //         wx.reLaunch({
        //             url: '/pages/order/pay_success',
        //         })
        //     },
        //     fail(e) {
        //         that.setData({ pay_waiting: true });
        //         return console.log('哈哈哈哈哈');
        //         // that.go_back()
        //     }
        // })
    },

    // 跳转vip界面
    go_vip() {
        let url = '/vip/vip'
        wx.navigateTo({
            url,
        })
    },

    go_ticket() {
        let url = '/pages/ticket/ticket'
        wx.navigateTo({
            url,
        })
    },

    // 最优优惠券筛选方法
    getBestCou() {
        // 选出金额最大的优惠券索引
        let couindex = 0, temMax = 0
        // 如果已用券，即对该券做过期提醒
        // console.log(this.data.couUseStatus);
        if (this.data.couUseStatus == 2) {
            couindex = this.data.couIndex
            temMax = this.data.couponValue
        } else {
            this.data.couponList.forEach((item, index) => {
                if (item.value > temMax) {
                    temMax = item.value
                    couindex = index
                }
            });
        }


        // console.log(timer);
        // 计算过期时间
        // if (!timer) {
        clearInterval(timer)

        timer = setInterval(() => {
            this.setData({
                bestUseTime: util.countDown(this.data.couponList[couindex].end_time)
            })
        }, 1000)
        // }

        this.setData({
            bestCouValue: temMax,
            bestCouIndex: couindex
        })
    },

    // 优惠券留客弹出框拉起
    async go_back() {
        // 判断是否有券可用 有则提示过期，无则提供领券
        if (this.data.couponList.length != 0) {
            // 筛选展示
            this.getBestCou()

        } else {
            // 发送请求筛选出可用优惠券，保存到 AvailableCou
            // 后台一张优惠券都没有就不再展示提示框，直接返回上一页
            let temList = await request.post(api.couponList, {})
            if (temList.length == 0) {
                wx.navigateBack({
                    delta: 1
                });
                return
            }


            // 收集商品id 筛选产品券是否可用
            let cartlist = this.data.cart_list
            let isNewUser = this.data.isNewUser
            // let isNewUser = true


            let cartids = []
            if (this.data.type == 0) {
                cartlist.forEach(item => { cartids.push(item.goods_id) })
            } else {
                cartlist.forEach(item => { cartids.push(item.id) })
            }

            let realList = temList.filter((item, index) => {
                switch (item.type) {
                    case 8:
                        return true
                        break;
                    case 1:
                        // 指定多商品
                        let idArr = item.condition.split(',')
                        let canUse = false
                        idArr.forEach(idstr => {
                            if (cartids.includes(parseInt(idstr)) && item.limit_sum <= this.data.total_price2) {
                                canUse = true
                                return
                            }
                        });
                        if (canUse) {
                            return true
                        } else {
                            return false
                        }
                        break;
                    case 7:
                        if (item.limit_sum <= this.data.total_price2) {
                            return true
                        }
                        break;
                    case 9:
                        if (isNewUser) {
                            return true
                        } else {
                            return false
                        }
                        break;
                    default:
                        return false
                        break;
                }
            })

            // 无优惠券满足本订单直接返回，不再展示提示框，直接返回上一页
            if (realList.length == 0) {
                wx.navigateBack({
                    delta: 1
                });
                return
            }

            this.setData({
                AvailableCou: realList
            })

            // 选出金额最大可领取的优惠券索引
            let couindex = 0, temMax = 0
            this.data.AvailableCou.forEach((item, index) => {
                if (item.value > temMax) {
                    temMax = item.value
                    couindex = index
                }
            });
            this.setData({
                AbestCouValue: temMax,
                AbestCouIndex: couindex
            })
        }
        this.setData({
            if_show_mask: true,
            if_show_end_paying_box: true
        })
    },

    // 领取最优优惠券
    async getThisCou(e) {
        let couid = e.currentTarget.dataset.couponId;
        // 携带id发送请求领取对应优惠券，添加到 couponList中
        // util.showLoading('领券中')
        let couDetail = await request.postall(api.getCoupon2, { uid: this.data.uid, id: couid })
        // util.hideLoading()
        if (couRes.code != 0) {
            return util.showToast(couRes.msg)
        } else {
            // 请求数据是异步的，需要等待完成避免报错
            await this.getAllmyCoupon()
            this.getAbledCoupon()
            this.getBestCou()

            this.setData({
                AvailableCou: [],
                btnText: '领取成功'
            })

            wx.showToast({
                title: '优惠券领取成功',
                duration: 2000
            })
        }

    },

    // 请求所有已领取且状态为可使用的优惠券
    async getAllmyCoupon() {
        let listRes = await request.post(api.myCouponList, { uid: this.data.uid, type: '1' })
        if (!listRes) listRes = []
        // 可用
        let canUseList = listRes.filter((item, index) => {
            if (item.is_userd == 0) return true
        })

        if (canUseList.length == 0) return
        this.setData({
            allCoupon: canUseList
        })
        // console.log('已领', this.data.allCoupon);
    },

    // 从所有领取优惠券筛选本订单可用优惠券
    getAbledCoupon() {
        // 收集商品id 筛选产品券是否可用
        let cartlist = this.data.cart_list
        // let isNewUser = this.data.isNewUser
        // let isNewUser = true


        let cartids = []
        if (this.data.type == 0) {
            cartlist.forEach(item => { cartids.push(item.goods_id) })
        } else {
            cartlist.forEach(item => { cartids.push(item.id) })
        }
        let temList = this.data.allCoupon
        // console.log(cartlist);
        // console.log(cartids);
        // console.log(temList);
        let realList = temList.filter((item, index) => {
            switch (item.type) {
                case 8:
                    return true
                    break;
                case 1:
                    // 指定多商品
                    let idArr = item.condition.split(',')
                    let canUse = false
                    idArr.forEach(idstr => {
                        if (cartids.includes(parseInt(idstr)) && item.limit_sum <= this.data.total_price2) {
                            canUse = true
                            return
                        }
                    });
                    if (canUse) {
                        return true
                    } else {
                        return false
                    }
                    break;
                case 7:
                    if (item.limit_sum <= this.data.total_price2) {
                        return true
                    }
                    break;
                // 非新用户虽然不能领取，但是领取过的还是可以正常使用
                case 9:
                    return true
                    // if (isNewUser) {
                    //     return true
                    // } else {
                    //     return false
                    // }
                    break;
                default:
                    return false
                    break;
            }
        })
        this.setData({
            couponList: realList
        })
    },

    // 继续支付
    continue_paying() {
        clearInterval(timer)
        this.setData({
            if_show_end_paying_box: false,
            if_show_mask: false,
        })
    },

    // 暂时放弃
    stop_paying() {
        // wx.switchTab({
        //     url: '/pages/home/home'
        // })
        clearInterval(timer)
        wx.navigateBack({
            delta: 1
        })
    },

    // 选择微信地址
    wx_choose_address() {
        const that = this
        // console.log('微信地址');
        util.showLoading('添加中')
        wx.chooseAddress({
            success: async (result) => {

                let params = {
                    uid: this.data.uid,
                    name: result.userName,
                    mobile: result.telNumber,

                    address: result.detailInfo,
                    is_default: 0
                }

                let pname = result.provinceName
                let cname = result.cityName
                let rname = result.countyName

                // 省份
                let provinceData = await that.getCityData()
                provinceData.forEach((item) => {
                    let oo = pname.indexOf(item.label)
                    if (oo != -1) {
                        params.province = item.value
                        params.province_name = item.label
                        return
                    }
                });

                // 城市
                let cityData = await that.getCityData(params.province)

                cityData.forEach((item) => {
                    let oo = cname.indexOf(item.label)
                    if (oo != -1) {
                        params.city = item.value
                        params.city_name = item.label
                        return
                    }
                });

                // 区县
                let regionData = await that.getCityData(params.city)

                regionData.forEach((item) => {
                    let oo = rname.indexOf(item.label)
                    if (oo != -1) {
                        params.region = item.value
                        params.area = item.value
                        params.region_name = item.label
                        return
                    }
                });
                console.log(params);

                request.post(api.addressadd, params).then(res => {
                    util.hideLoading()
                    that.get_address()
                    // this.onLoad(this.data.options)
                })
            },
            fail: (err) => {
                console.log('err', err);
                util.hideLoading()

            }
        })
    },

    // 获取省市区方法
    async getCityData(code = '') {
        let res = await request.postall(api.getcity, { code })
        if (res.code == 0) {
            let conData = res.data.con
            conData.forEach(item => {
                item.label = item.name
                item.value = item.code
            });
            return conData
        } else {
            util.showFail('地区信息获取失败')
        }
    },

    // 继续支付
    paying_waiting() {
        // 用户取消付款 去订单列表继续付款按钮的回调
        // wx.navigateTo({
        //     url: '/pages/order/list?index=1'
        // })

        // 留在本页面继续调起该订单的支付
        // request.post(api.orderpay3, { id: this.data.orderIdCode }).then(res => {
        //     // res包含拉起微信支付的参数
        //     this.wx_pay(res)
        // })


        this.wx_pay(this.pay_post_data)
    },

    go_good_detail(e) {
        let id = e.currentTarget.dataset.id
        if (!id) {
            util.showToast('所选商品暂无记录')
            return
        }
        wx.navigateTo({
            url: '/pages/good/detail?id=' + id,
        })
    },

    keyboardheightchange(e) {
        let keyboardheight = e?.detail?.height || 0
        this.setData({
            if_show_mask: keyboardheight == 0 ? false : true,
            positionStauts: keyboardheight == 0 ? 'relative' : 'fixed',
            keyboardheight: keyboardheight,
            zindex: keyboardheight == 0 ? 5 : 10
        })
        // console.log(keyboardheight);
    },

    onShow: async function () {
        let returnOptions = wx.getEnterOptionsSync();

        console.log(returnOptions.scene, returnOptions.referrerInfo.appId, returnOptions.path);
        // 特殊说明：
        // 一般情况下wx.getEnterOptionsSync()中获取的extraData为收银台小程序返回的支付结果，
        // 但是当通过物理返回键或者通过半屏小程序右上角关闭退出（即未通过收银台小程序内按钮退出），
        // extraData内容会为空，调用方小程序会无法获得支付结果，该情况为微信小程序特性，小程序代码无法处理。
        // 如遇到该情况，通过判断场景值为1038且来源小程序为收银台小程序wxef277996acc166c3（上述代码加粗部分），
        // 即可认定为收银台返回，当前若extraData为空，则需要自行查询订单支付结果
        if (returnOptions.scene == '1038' && returnOptions.referrerInfo.appId == 'wxef277996acc166c3') {
            // 必须清除，否则会被自动保留下来，金顶的其他页面进入支付页也会跳提示。（未知bug）
            // 从收银台返回会重新获取，所以不影响判断支付结果
            returnOptions.scene = ""
            returnOptions.referrerInfo.appId = ""
            // 代表从收银台小程序返回
            let extraData = returnOptions.referrerInfo.extraData;
            console.log("extraData", extraData);
            if (!extraData) {
                // "当前通过物理按键返回，未接收到返参，建议自行查询交易结果";
                // util.showToast("物理按键返回，未获取支付结果")

                util.showLoading("支付结果检测中")
                setTimeout(async () => {
                    let oid = this.data.orderIdCode
                    let orderInfo = await request.post(api.orderdetail, { id: oid })
                    util.hideLoading()
                    console.log("orderInfo", orderInfo);
                    if (orderInfo.pay_status == 1) {
                        // 支付成功 
                        util.showToast("支付成功")
                        wx.reLaunch({
                            url: '/pages/order/pay_success',
                        })
                    } else {
                        // 支付取消
                        util.showToast("支付已取消")
                        this.setData({ pay_waiting: true });
                    }
                }, 1000);

            } else {

                if (extraData.code == 'success') {

                    // "支付成功";
                    util.showToast("支付成功")
                    wx.reLaunch({
                        url: '/pages/order/pay_success',
                    })

                } else if (extraData.code == 'cancel') {

                    // "支付已取消";
                    util.showToast("支付已取消")
                    this.setData({ pay_waiting: true });

                } else {
                    // "支付失败：" + extraData.errmsg;
                    util.showToast("支付失败")
                }
            }
        }

        if (App.globalData.isVip != this.data.isVip) {
            this.init_data(this.data.options)
        }
        // this.get_address_list()
        await this.get_address()
        await this.getAllmyCoupon()
        await this.getAbledCoupon()
    },

})